home *** CD-ROM | disk | FTP | other *** search
/ Network CD 1 / Network CD.iso / fredfish / 811-820 / ff813 / minedout / cookie.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-02-14  |  15.6 KB  |  456 lines
  1.  
  2. /*
  3.  * Cookie.c
  4.  *
  5.  * Call it with: dcc Mined_Out.c About.c Cookie.c Graphics.c Highscore.c
  6.  *                   Opal_12.c Play_Game.c Sound.c
  7.  *                   -o Mined_Out
  8.  *               Mined_Out [-Test] [Columns Rows]
  9.  */
  10.  
  11. /*
  12.  * This loads the Cookie.dat file and prints some Cookies.
  13.  * If you think the list generated here is mindbreaking than you are righ&%$#§$%§$"$
  14.  * Cookie.dat should not contain lines with Buffer_Size characters!!!
  15.  */
  16.  
  17. /*
  18.  * Copyright by: Dieter Seidel
  19.  *               Einsteinstraße 19
  20.  *          7410 Reutlingen
  21.  *               Germany
  22.  */
  23.  
  24. #include <exec/types.h>
  25. #include <stdio.h>                           /* For fgets()
  26. #include <string.h>                          /* For strcmp(), strlen() */
  27. #include <intuition/intuition.h>
  28.  
  29.  
  30. extern BOOL   Test_Modus;                    /* Declared in Mined_Out.c */
  31. extern UWORD  WBenchScreen_Width,            /* Declared in Mined_Out.c */
  32.               WBenchScreen_Height;
  33. extern struct TextFont *TopazFont_9;         /* Declared in Mined_Out.c */
  34. extern struct TextFont *TopazFont_8;         /* Declared in Mined_Out.c */
  35. extern struct TextFont  OpalFont;            /* Declared in Opal_12.c   */
  36.  
  37. extern struct IntuitionBase *IntuitionBase;  /* Declared in Mined_Out.c */
  38. extern struct GfxBase       *GfxBase;        /* Declared in Mined_Out.c */
  39.  
  40. const int Letter_Delay_Time  = 2;            /* 2 Tics delay for every Letter */
  41. const int General_Delay_Time = 300;          /* Give 6 secs for searching     */
  42.                                              /* Cookie window                 */
  43.  
  44. int Quantity_Cookies;                 /* Number of Cookies in file Cookie.dat */
  45.  
  46. struct Cookie                                /* Contains the Cookies */
  47.        {
  48.          char          *Text;                /* 1st, 2nd 3rd Line, and so on */
  49.          struct Cookie *Next_Line;
  50.        };
  51.  
  52. struct Cookie_List
  53.        {
  54.          struct Cookie      *Text_List;
  55.          struct Cookie_list *Next_Cookie;
  56.        };
  57.  
  58. struct Cookie_List *Cookies;
  59.  
  60.  
  61. #define Buffer_Size 80          /* Only lines with <> 80 characters are read */
  62.                                 /* correctly (inclusive newline characters). */
  63.                                 /* Otherwise fgets(...) fools me.            */
  64.  
  65.  
  66. struct Window    *Cookie_Window;                 /* Shows the Fortune Cookie */
  67. struct NewWindow  Cookie_New_Window =
  68. {
  69.   0,                /* LeftEdge    */
  70.   0,                /* TopEdge     */
  71.   0,                /* Width       */
  72.   0,                /* Height      */
  73.   0,                /* DetailPen   */
  74.   1,                /* BlockPen    */
  75.   NULL,             /* IDCMPFlags  */
  76.   SMART_REFRESH|    /* Flags       */
  77.   WINDOWDRAG,
  78.   NULL,             /* FirstGadget */
  79.   NULL,             /* CheckMark   */
  80.   (char *)"",       /* Title       */
  81.   NULL,             /* Screen      */
  82.   NULL,             /* BitMap      */
  83.   0,                /* MinWidth    */
  84.   0,                /* MinHeight   */
  85.   0,                /* MaxWidth    */
  86.   0,                /* MaxHeight   */
  87.   WBENCHSCREEN      /* Type        */
  88. };
  89.  
  90.  
  91. extern void Close_Libraries(void);           /* Declared in Mined_Out.c */
  92. extern void Close_Fonts(void);               /* Declared in Mined_Out.c */
  93.  
  94.  
  95. void Load_Cookies(void)
  96. {
  97.   FILE *Cookie_File;                         /* Local variables for Load_Cookies */
  98.   char *File_Name = "Data/Cookie.dat";
  99.   struct Cookie_List *New_Cookie_List;
  100.   struct Cookie      *New_String_List;
  101.   BOOL Buffer_Inserted;                      /* Detects the end of a cookie      */
  102.   char Buffer[Buffer_Size];                  /* Be sure that Cookie.dat contains */
  103.                                         /* no lines with Buffer_Size characters. */
  104.   Cookies          = NULL;
  105.   Quantity_Cookies = 0;                      /* No Cookies loaded */
  106.   New_Cookie_List  = NULL;
  107.   New_String_List  = NULL;
  108.   Buffer_Inserted  = FALSE;
  109.  
  110.   Cookie_File = fopen(File_Name, "r");       /* Read Cookie.dat */
  111.   if (!Cookie_File)
  112.     if (Test_Modus)
  113.       printf("Unable to open Cookies.dat.\n");
  114.     else
  115.       ;                                      /* I hate this. Really. */
  116.   else
  117.   {                                          /* Now reading Cookie.dat */
  118.     while (fgets(Buffer, sizeof(Buffer), Cookie_File))
  119.     {
  120.       if (strlen(Buffer) == 1)               /* Empty line readed. Next Cookie expected */
  121.       {
  122.         if (Buffer_Inserted)
  123.           Quantity_Cookies++;
  124.         Buffer_Inserted = FALSE;
  125.       }
  126.       else                                   /* Insert String */
  127.       {
  128.         if (New_Cookie_List == NULL)
  129.         {
  130.           New_Cookie_List = (struct Cookie_List *) malloc(sizeof(struct Cookie_List));
  131.           Cookies = New_Cookie_List;         /* Set start of Cookie List */
  132.           New_Cookie_List->Next_Cookie = NULL;
  133.           New_String_List = (struct Cookie *) malloc(sizeof(struct Cookie));
  134.           New_Cookie_List->Text_List = New_String_List;
  135.           New_String_List->Next_Line = NULL;
  136.           New_String_List->Text = (char *) malloc(strlen(Buffer));
  137.           strcpy(New_String_List->Text, Buffer);
  138.           Buffer_Inserted = TRUE;
  139.         }
  140.         else
  141.         {
  142.           if (Buffer_Inserted)
  143.           {
  144.             New_String_List->Next_Line = (struct Cookie *)
  145.                                          malloc(sizeof(struct Cookie));
  146.             New_String_List->Next_Line->Next_Line = NULL;
  147.             New_String_List->Next_Line->Text = (char *) malloc(strlen(Buffer));
  148.             strcpy(New_String_List->Next_Line->Text, Buffer);
  149.             New_String_List = New_String_List->Next_Line;
  150.           }
  151.           else
  152.           {
  153.             New_Cookie_List->Next_Cookie = (struct Cookie_List *)
  154.                                            malloc(sizeof(struct Cookie_List));
  155.             New_String_List = (struct Cookie *) malloc(sizeof(struct Cookie));
  156.             New_String_List->Next_Line = NULL;
  157.             New_String_List->Text = (char *) malloc(strlen(Buffer));
  158.             strcpy(New_String_List->Text, Buffer);
  159.             New_Cookie_List = New_Cookie_List->Next_Cookie;
  160.             New_Cookie_List->Next_Cookie = NULL;
  161.             New_Cookie_List->Text_List = New_String_List;
  162.             Buffer_Inserted = TRUE;
  163.           }
  164.         }
  165.       }
  166.     }
  167.     if (Buffer_Inserted)                     /* Cookie.dat does not end with */
  168.       Quantity_Cookies++;                    /* an newline character.        */
  169.     fclose(Cookie_File);                     /* All readed from Cookie.dat.  */
  170.  
  171.     if (Test_Modus)
  172.     {
  173.       printf("%d Cookies readed. Now printing them.\n\n",Quantity_Cookies);
  174.       New_Cookie_List = Cookies;
  175.       if (New_Cookie_List)
  176.         New_String_List = Cookies->Text_List;
  177.       else
  178.         New_String_List = NULL;           /* No Cookies loaded, so don't print them */
  179.       printf("Cookie:\n");
  180.       while (New_String_List)
  181.       {
  182.         printf("%s", New_String_List->Text);
  183.         New_String_List = New_String_List->Next_Line;
  184.         if (New_String_List == NULL)
  185.         {
  186.           printf("\nCookie:\n");
  187.           New_Cookie_List = New_Cookie_List->Next_Cookie;
  188.           if (New_Cookie_List)
  189.             New_String_List = New_Cookie_List->Text_List;
  190.         }
  191.       }
  192.     }   /* Of Test_Modus */
  193.   }
  194. }
  195.  
  196.  
  197. void Remove_Cookie_List(void)
  198. {
  199. }
  200.  
  201.  
  202.                           /* Get the Pointer to the n.th Cookie. */
  203. struct Cookie_List *Get_Cookie_Pointer(void)
  204. {
  205.   struct Cookie_List *Cookie_Pointer;
  206.   int Random_Number = rand();
  207.  
  208.   if (Quantity_Cookies == 0)
  209.     return(NULL);                     /* No Cookies available */
  210.   else
  211.   {
  212.     Random_Number %= (Quantity_Cookies + 1);
  213.     Cookie_Pointer = Cookies;
  214.     while ((Random_Number > 1) && (Cookie_Pointer))
  215.     {
  216.       Cookie_Pointer = Cookie_Pointer->Next_Cookie;
  217.       Random_Number--;            /* C Hackers would put this in the while Condition */
  218.     }
  219.     return(Cookie_Pointer);
  220.   }
  221. }
  222.  
  223.  
  224. int Get_Lines(struct Cookie_List *Cookie_To_Print)
  225. {
  226.   int Count_Lines = 0;            /* No lines countet */
  227.   struct Cookie *Next_Line;
  228.  
  229.   if (Cookie_To_Print)            /* Prevent Guru Meditation */
  230.   {
  231.     Next_Line = Cookie_To_Print->Text_List;
  232.     while (Next_Line)
  233.     {
  234.       Count_Lines++;
  235.       Next_Line = Next_Line->Next_Line;
  236.     }
  237.   }
  238.   return(Count_Lines);
  239. }
  240.  
  241.  
  242. int Count_Letters(struct Cookie_List *Cookie_To_Print)
  243. {
  244.   int Count_Letters = 0;
  245.   struct Cookie *Next_Line;
  246.  
  247.   if (Cookie_To_Print)
  248.   {
  249.     Next_Line = Cookie_To_Print->Text_List;
  250.     while (Next_Line)
  251.     {
  252.       Count_Letters += strlen(Next_Line->Text);
  253.       Next_Line = Next_Line->Next_Line;
  254.     }
  255.   }
  256.   return(Count_Letters);
  257. }
  258.  
  259.  
  260. int Get_Max_Line_Length(struct Cookie_List *Cookie_To_Print)
  261. {
  262.   int Max_Line_Length = 0;    /* Set minimum length */
  263.   struct Cookie *Next_Line;
  264.  
  265.   if (Cookie_To_Print)
  266.   {
  267.     Next_Line = Cookie_To_Print->Text_List;
  268.     while (Next_Line)
  269.     {
  270.       if (strlen(Next_Line->Text) > Max_Line_Length)
  271.         Max_Line_Length = strlen(Next_Line->Text);
  272.       Next_Line = Next_Line->Next_Line;
  273.     }
  274.   }
  275.   return(Max_Line_Length);
  276. }
  277.  
  278.  
  279. BOOL Print_Cookie(void)
  280. {
  281.   struct Cookie_List *Cookie_To_Print;                           /* Local variables */
  282.  
  283.   Cookie_New_Window.Title = (char *) "Fortune Cookie";          /* Set Window Title */
  284.   Cookie_To_Print = Get_Cookie_Pointer();
  285.   if (Cookie_To_Print == NULL)
  286.   {                                       /* Print `All Cookies are broken' */
  287.     Cookie_New_Window.Width    = 330;     /* 31 Letters * 10 Fontsize + 2*10 Border */
  288.     Cookie_New_Window.Height   = 30;
  289.     Cookie_New_Window.LeftEdge = (WBenchScreen_Width  - 303) / 2;
  290.     Cookie_New_Window.TopEdge  = (WBenchScreen_Height - 28 ) / 2;
  291.  
  292.     Cookie_Window = (struct Window *) OpenWindow(&Cookie_New_Window);
  293.     if (Cookie_Window == NULL)
  294.     {
  295.       printf("Could not open Fortune Cookie Window\n");
  296.       Close_Libraries();
  297.       Close_Fonts();
  298.       exit(1000);
  299.     }
  300.     SetAPen(Cookie_Window->RPort, 1);
  301.     SetDrMd(Cookie_Window->RPort, JAM1);
  302.     SetFont(Cookie_Window->RPort, TopazFont_9);
  303.     Move(Cookie_Window->RPort, 10, 22);
  304.     Text(Cookie_Window->RPort, "All Fortune Cookies are broken.", 31);
  305.     Delay(Letter_Delay_Time * 31 + General_Delay_Time);
  306.     if (Cookie_Window)
  307.       CloseWindow(Cookie_Window);
  308.   }
  309.   else
  310.   {                                                              /* Print Cookie */
  311.     int How_Many_Lines   = Get_Lines(Cookie_To_Print);           /* Local variables */
  312.     int How_Many_Letters = Count_Letters(Cookie_To_Print);
  313.     int Max_Line_Length  = Get_Max_Line_Length(Cookie_To_Print);
  314.     int Display_Row      = 22;         /* Row of the first line from the Cookie ... */
  315.     struct Cookie *Next_Line;
  316.  
  317.     Cookie_New_Window.Width    = Max_Line_Length * 8 + 2 * 10;
  318.     if (Cookie_New_Window.Width > WBenchScreen_Width)
  319.     {
  320.       if (Test_Modus)
  321.         printf("The width of the Cookie is to large. Can't open Window!\n");
  322.       return(FALSE);
  323.     }
  324.     Cookie_New_Window.Height   = 21 + 8 * How_Many_Lines;
  325.     if (Cookie_New_Window.Height > WBenchScreen_Height)
  326.     {
  327.       if (Test_Modus)
  328.         printf("The height of the Cookie is to large. Can't open Window!\n");
  329.       return(FALSE);
  330.     }
  331.     Cookie_New_Window.LeftEdge = (WBenchScreen_Width  - Cookie_New_Window.Width ) / 2;
  332.     Cookie_New_Window.TopEdge  = (WBenchScreen_Height - Cookie_New_Window.Height) / 2;
  333.  
  334.     Cookie_Window = (struct Window *) OpenWindow(&Cookie_New_Window);
  335.     if (Cookie_Window == NULL)
  336.     {
  337.       printf("Could not open Fortune Cookie Window\n");
  338.       Close_Libraries();
  339.       Close_Fonts();
  340.       exit(1000);
  341.     }
  342.     SetAPen(Cookie_Window->RPort, 1);
  343.     SetDrMd(Cookie_Window->RPort, JAM1);
  344.     SetFont(Cookie_Window->RPort, TopazFont_8);
  345.     Next_Line = Cookie_To_Print->Text_List;
  346.     while (Next_Line)
  347.     {
  348.       Move(Cookie_Window->RPort, 10, Display_Row);
  349.       Text(Cookie_Window->RPort, Next_Line->Text, strlen(Next_Line->Text) - 1);
  350.       Next_Line = Next_Line->Next_Line;
  351.       Display_Row += 8;
  352.     }
  353.     Delay(Letter_Delay_Time * How_Many_Letters + General_Delay_Time);
  354.     if (Cookie_Window)
  355.       CloseWindow(Cookie_Window);
  356.   }
  357.   return(TRUE);
  358. }
  359.  
  360.  
  361. BOOL Print_Cookie_Dead(void)
  362. {
  363.   struct Cookie_List *Cookie_To_Print;       /* Local variables */
  364.  
  365.   Cookie_New_Window.Title = (char *) "You are DEAD!";        /* Set Window Title */
  366.   Cookie_To_Print = Get_Cookie_Pointer();
  367.   if (Cookie_To_Print == NULL)
  368.   {                                       /* Print `All Cookies are broken' */
  369.     Cookie_New_Window.Width    = 330;     /* 31Letters * 10Fontsize + 2*10Border */
  370.     Cookie_New_Window.Height   = 30;
  371.     Cookie_New_Window.LeftEdge = (WBenchScreen_Width  - 303) / 2;
  372.     Cookie_New_Window.TopEdge  = (WBenchScreen_Height - 28 ) / 2;
  373.  
  374.     Cookie_Window = (struct Window *) OpenWindow(&Cookie_New_Window);
  375.     if (Cookie_Window == NULL)
  376.     {
  377.       printf("Could not open Fortune Cookie Window\n");
  378.       Close_Libraries();
  379.       Close_Fonts();
  380.       exit(1000);
  381.     }
  382.     SetAPen(Cookie_Window->RPort, 1);
  383.     SetDrMd(Cookie_Window->RPort, JAM1);
  384.     SetFont(Cookie_Window->RPort, TopazFont_9);
  385.     Move(Cookie_Window->RPort, 10, 22);
  386.     Text(Cookie_Window->RPort, "All Fortune Cookies are broken.", 31);
  387.     Delay(Letter_Delay_Time * 31 + General_Delay_Time);
  388.     if (Cookie_Window)
  389.       CloseWindow(Cookie_Window);
  390.   }
  391.   else
  392.   {                                                              /* Print Cookie */
  393.     int How_Many_Lines   = Get_Lines(Cookie_To_Print);           /* Local variables */
  394.     int How_Many_Letters = Count_Letters(Cookie_To_Print);
  395.     int Max_Line_Length  = Get_Max_Line_Length(Cookie_To_Print);
  396.     int Display_Row      = 22 + 36;    /* Row of the first line from the Cookie ... */
  397.     struct Cookie *Next_Line;
  398.  
  399.     Cookie_New_Window.Width    = Max_Line_Length * 8 + 2 * 10;
  400.     if (Cookie_New_Window.Width > WBenchScreen_Width)
  401.     {
  402.       if (Test_Modus)
  403.         printf("The width of the Cookie is to large. Can't open Window!\n");
  404.       return(FALSE);
  405.     }
  406.     if (Cookie_New_Window.Width < (42 * 9 + 2 * 10 + 40))
  407.       Cookie_New_Window.Width = 42 * 9 + 2 * 10 + 40;
  408.                         /* 44 characters for the text from god * 9 character size */
  409.                         /* + 2 * 10 Border + 2 * 20 extra border.                 */
  410.     Cookie_New_Window.Height  = 21 + 36 + 8 * How_Many_Lines;
  411.     if (Cookie_New_Window.Height > WBenchScreen_Height)
  412.     {
  413.       if (Test_Modus)
  414.         printf("The height of the Cookie is to large. Can't open Window!\n");
  415.       return(FALSE);
  416.     }
  417.     Cookie_New_Window.LeftEdge = (WBenchScreen_Width  - Cookie_New_Window.Width ) / 2;
  418.     Cookie_New_Window.TopEdge  = (WBenchScreen_Height - Cookie_New_Window.Height) / 2;
  419.  
  420.     Cookie_Window = (struct Window *) OpenWindow(&Cookie_New_Window);
  421.     if (Cookie_Window == NULL)
  422.     {
  423.       printf("Could not open Fortune Cookie Window\n");
  424.       Close_Libraries();
  425.       Close_Fonts();
  426.       exit(1000);
  427.     }
  428.     SetAPen(Cookie_Window->RPort, 1);
  429.     SetDrMd(Cookie_Window->RPort, JAM1);
  430.     SetFont(Cookie_Window->RPort, &OpalFont);
  431.     Move(Cookie_Window->RPort, 30, 22);
  432.     Text(Cookie_Window->RPort, "After you reached heaven, God speaks to you:", 44);
  433.     Move(Cookie_Window->RPort, 66, 34);
  434.     Text(Cookie_Window->RPort, "`I give you another chance on earth'", 36);
  435.     Move(Cookie_Window->RPort, 30, 46);
  436.     Text(Cookie_Window->RPort, "and hands an Fortune Cookie to you.", 35);
  437.  
  438.     SetAPen(Cookie_Window->RPort, 1);
  439.     SetDrMd(Cookie_Window->RPort, JAM1);
  440.     SetFont(Cookie_Window->RPort, TopazFont_8);
  441.     Next_Line = Cookie_To_Print->Text_List;
  442.     while (Next_Line)
  443.     {
  444.       Move(Cookie_Window->RPort, 10, Display_Row);
  445.       Text(Cookie_Window->RPort, Next_Line->Text, strlen(Next_Line->Text) - 1);
  446.       Next_Line = Next_Line->Next_Line;
  447.       Display_Row += 8;
  448.     }
  449.     Delay(Letter_Delay_Time * How_Many_Letters + General_Delay_Time);
  450.     if (Cookie_Window)
  451.       CloseWindow(Cookie_Window);
  452.   }
  453.   return(TRUE);
  454. }
  455.  
  456.